package main

import (
	"fmt"
	"math"
)

/*
特别提示：
	1、整型参数，min 和 max 的参数可以交换和组合。
	2、字符串类型参数，min 和 max 的参数逐个字节比较，得出最小/最大的字符串，参数可以交换和组合。
	3、浮点型参数-0.0 和 0.0 作为参数，-0.0 小于 0.0；负无穷大，小于任意其它数值；正无穷大，大于任意其它数值。
	4、min 和 max 的任意参数是 NaN[1]，则返回结果是 NaN ("not-a-number") 值。
*/

func main() {
	//函数 max 和函数 min 的使用方式相同，返回结果相反
	//整型参数
	m := min(1, 2)
	fmt.Printf("m最小值：%v\n", m)

	m1 := max(1, 2)
	fmt.Printf("m1最大值：%v\n", m1)

	//参数为浮点数类型，包含 NaN，返回结果则是 NaN
	m2 := min(3.14, math.NaN(), 1.0)
	fmt.Printf("m2最小值：%v\n", m2)

	//整型参数 1、浮点型参数 2.0 和整型参数 3，返回值赋值给参数 c，打印 c 的类型和值，
	//输出结果为 float64 1，即三个参数中值最小的参数的值。
	c := min(1, 2.0, 3) //一般都是同类型的比较
	fmt.Printf("%T\t%v\n", c, c)

	//字符串
	t := min("foo", "bar")
	fmt.Printf("t最小值：%v\n", t) // bar

	t1 := max("foo", "bar")
	fmt.Printf("t1最大值：%v\n", t1) // bar

	//如果有空字符串，则返回空字符串
	t2 := min("", "foo", "bar")
	fmt.Printf("t2最小值：%v\n", t2)

	/*
		如果是 map，则删除 map 中的所有元素，返回一个空 map；如果是 slice，则将 slice 中的所有元素改为切片类型的零值。
	*/
	s := []int{1, 2, 3}
	fmt.Printf("len=%d\t s=%+v\n", len(s), s) // len=3      s=[1 2 3]
	clear(s)
	fmt.Printf("len=%d\t s=%+v\n", len(s), s) // len=3      s=[0 0 0]

	ma := map[string]int{"go": 100, "php": 80}
	fmt.Printf("len=%d\tm=%+v\n", len(ma), ma) // len=2   m=map[go:100 php:80]
	clear(ma)
	fmt.Printf("len=%d\tm=%+v\n", len(ma), ma) // len=0   m=map[]

	d := []Data{
		{
			User:   map[int]string{1: "frank", 2: "lucy"},
			Salary: map[string]int{"frank": 1000, "lucy": 2000},
		},
	}
	fmt.Printf("d=%+v\n", d) // d=[{User:map[1:frank 2:lucy] Salary:map[frank:1000 lucy:2000]}]
	clear(d)
	fmt.Printf("d=%+v\n", d) // d=[{User:map[] Salary:map[]}]

	d1 := []Data1{
		{
			User:   "frank",
			Salary: 1000,
		},
	}
	fmt.Printf("d1=%+v\n", d1) // d1=[{User:frank Salary:1000}]
	clear(d1)
	fmt.Printf("d1=%+v\n", d1) // d1=[{User: Salary:0}]
}

type Data struct {
	User   map[int]string
	Salary map[string]int
}

type Data1 struct {
	User   string
	Salary int
}
